/*
 * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpOption;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.SSLContext;

import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestExchange;
import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestHandler;
import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestServer;
import jdk.test.lib.net.SimpleSSLContext;
import jdk.test.lib.net.URIBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static java.net.http.HttpClient.Builder.NO_PROXY;
import static java.net.http.HttpClient.Version.HTTP_3;
import static java.net.http.HttpOption.Http3DiscoveryMode.HTTP_3_URI_ONLY;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;

/*
 * @test
 * @bug 8371802
 * @summary verify that if a higher idle timeout is configured for a HTTP/3 connection
 *          then a lower negotiated QUIC idle timeout doesn't cause QUIC to
 *          idle terminate the connection
 * @library /test/lib /test/jdk/java/net/httpclient/lib
 * @build jdk.httpclient.test.lib.common.HttpServerAdapters
 *        jdk.test.lib.net.SimpleSSLContext
 *
 * @comment this test has some explicit delays to simulate a idle connection, the timeout=180
 *          is merely to provide some leeway to the test and prevent timing out the test on busy
 *          systems
 * @run junit/othervm/timeout=180 -Djdk.httpclient.quic.idleTimeout=30
 *                    -Djdk.httpclient.keepalive.timeout.h3=120
 *                    ${test.main.class}
 */
class H3IdleExceedsQuicIdleTimeout {

    private static final String REQ_PATH = "/8371802";

    private static HttpTestServer h3Server;
    private static SSLContext sslCtx;

    @BeforeAll
    static void beforeAll() throws Exception {
        sslCtx = new SimpleSSLContext().get();
        assert sslCtx != null : "SSLContext is null";
        h3Server = HttpTestServer.create(HTTP_3_URI_ONLY, sslCtx);
        h3Server.addHandler(new Handler(), REQ_PATH);
        h3Server.start();
        System.err.println("HTTP/3 server started at " + h3Server.getAddress());
    }

    @AfterAll
    static void afterAll() throws Exception {
        if (h3Server != null) {
            System.err.println("stopping server at " + h3Server.getAddress());
            h3Server.stop();
        }
    }

    /*
     * With QUIC idle connection timeout configured to be lower than the HTTP/3 idle timeout,
     * this test issues a HTTP/3 request and expects that request to establish a QUIC connection
     * and receive a successful response. The test then stays idle for a duration larger
     * than the QUIC idle timeout and issues a HTTP/3 request again after that idle period.
     * The test then expects that the second request too is responded by the previously opened
     * connection, thus proving that the QUIC layer did the necessary work to prevent the (idle)
     * connection from terminating.
     */
    @Test
    void testQUICKeepsConnAlive() throws Exception {
        final long quicIdleTimeoutSecs = 30;
        assertEquals(quicIdleTimeoutSecs,
                Integer.parseInt(System.getProperty("jdk.httpclient.quic.idleTimeout")),
                "unexpected QUIC idle timeout");
        assertEquals(120,
                Integer.parseInt(System.getProperty("jdk.httpclient.keepalive.timeout.h3")),
                "unexpected HTTP/3 idle timeout");
        try (final HttpClient client = HttpClient.newBuilder()
                .sslContext(sslCtx)
                .proxy(NO_PROXY)
                .version(HTTP_3)
                .build()) {

            final URI req1URI = URIBuilder.newBuilder()
                    .scheme("https")
                    .host(h3Server.getAddress().getAddress())
                    .port(h3Server.getAddress().getPort())
                    .path(REQ_PATH)
                    .query("i=1")
                    .build();
            System.err.println("issuing request " + req1URI);
            final HttpRequest req1 = HttpRequest.newBuilder()
                    .uri(req1URI)
                    .setOption(HttpOption.H3_DISCOVERY, HTTP_3_URI_ONLY)
                    .build();
            final HttpResponse<Void> resp1 = client.send(req1, BodyHandlers.discarding());
            assertEquals(200, resp1.statusCode(), "unexpected status code");
            final String resp1ConnLabel = resp1.connectionLabel().orElse(null);
            System.err.println("first request handled by connection: " + resp1ConnLabel);
            assertNotNull(resp1ConnLabel, "missing connection label on response");
            assertEquals(HTTP_3, resp1.version(), "unexpected response version");
            // don't generate any more traffic from the HTTP/3 side for longer than the QUIC
            // idle timeout
            stayIdle(quicIdleTimeoutSecs + 13, TimeUnit.SECONDS);
            // now send the HTTP/3 request and expect the same previous connection to handle
            // respond to this request
            final URI req2URI = URIBuilder.newBuilder()
                    .scheme("https")
                    .host(h3Server.getAddress().getAddress())
                    .port(h3Server.getAddress().getPort())
                    .path(REQ_PATH)
                    .query("i=2")
                    .build();
            System.err.println("issuing request " + req2URI);
            final HttpRequest req2 = HttpRequest.newBuilder()
                    .uri(req2URI)
                    .setOption(HttpOption.H3_DISCOVERY, HTTP_3_URI_ONLY)
                    .build();
            final HttpResponse<Void> resp2 = client.send(req2, BodyHandlers.discarding());
            assertEquals(200, resp2.statusCode(), "unexpected status code");
            final String resp2ConnLabel = resp2.connectionLabel().orElse(null);
            System.err.println("second request handled by connection: " + resp2ConnLabel);
            assertEquals(resp1ConnLabel, resp2ConnLabel, "second request handled by a different connection");
            assertEquals(HTTP_3, resp2.version(), "unexpected response version");
        }
    }

    private static void stayIdle(final long time, final TimeUnit unit) throws InterruptedException {
        // await on a CountDownLatch which no one counts down. this is merely
        // to avoid using Thread.sleep(...) and other similar constructs and then
        // having to deal with spurious wakeups.
        final boolean countedDown = new CountDownLatch(1).await(time, unit);
        assertFalse(countedDown, "wasn't expected to be counted down");
    }

    private static final class Handler implements HttpTestHandler {
        private static final int NO_RESP_BODY = 0;

        @Override
        public void handle(final HttpTestExchange exchange) throws IOException {
            System.err.println("handling request " + exchange.getRequestURI());
            exchange.sendResponseHeaders(200, NO_RESP_BODY);
        }
    }
}
